define("base", [], function (Lyx) {

	"use strict";

	/**
	 * 基础函数扩展
	 * @exports base
	 */
	var base = {};

	/**
	 * 建立网络数据池
	 * @constructor
	 * @param {object} pool 数据池
	 * @param {object} model 数据对象模板
	 * @param {function} getWebFunc 网络通信函数
	 * @param {function} [setFunc = false] 属性设置函数
	 */
	base.pool = Lyx.createClass(function (p2t) {
		p2t.init = function (pool, model, getWebFunc, setFunc) {
			/**
			 *  数据池
			 * @member {object}
			 */
			this.pool = pool;

			/** 
			 * 数据池中类型原型
			 * @member {object}
			 */
			this.model = model;

			/** 
			 * 网络通信函数
			 * @member {object}
			 */
			this.getWebFunc = getWebFunc;

			/** 
			 * 设置对象属性 
			 * @member {function}
			 */
			this.setFunc = setFunc || function (obj, name, value) {
				obj[name] = value;
			};

			/** 
			 * 存储多个id，用于统一请求
			 * @member {array}
			 */
			this.idList = [];

			/** 
			 * 正在请求的id，防止重复获取
			 * @member {object}
			 */
			this.requestBuffer = {};
		}

		/** 
		 * 删除数据池中的数据
		 * @memberof module:base.pool.prototype
		 * @param {string} id 要删除的id
		 */
		p2t.del = function (id) {
			delete this.pool[id];
		}

		/**
		 * 将需要加载id统一保存，当id不存在时，会在数据池中分配空值，然后统一请求
		 * @memberof module:base.pool.prototype
		 * @param {string} id 要加载的id
		 * @returns {Object} 返回数据池中该id的值
		 */
		p2t.setId = function (id) {
			if (Lyx.isUndefined(this.pool[id])) {
				this.setFunc(this.pool, id, base.copy(this.model));
				this.idList.push(id);
			}
			return this.pool[id];
		}

		/**
		 * 获取数据池中id对应的元素，当id不存在时，会在数据池中分配空值，并向网络请求该id
		 * @memberof module:base.pool.prototype
		 * @param {string} id 要获取的id
		 */
		p2t.getId = function (id) {
			if (Lyx.isUndefined(this.pool[id])) {
				this.setFunc(this.pool, id, base.copy(this.model));
				if (Lyx.isUndefined(this.requestBuffer[id])) {
					this.requestBuffer[id] = "";
					this.getWebFunc([id]);
				}
			}
			return this.pool[id];
		}

		/**
		 * 一次性请求idList中的所有id
		 * @memberof module:base.pool.prototype
		 */
		p2t.getList = function () {
			if (this.idList.length == 0) return;
			var list = [];
			Lyx.each(this.idList, function (index, id) {
				if (Lyx.isUndefined(this.requestBuffer[id])) {
					this.requestBuffer[id] = "";
					list.push(id);
				}
			}, this);
			this.getWebFunc(list);
			this.idList = [];
		}

		/**
		 * 设置数据
		 * @memberof module:base.pool.prototype
		 * @param map 数据
		 */
		p2t.setModel = function (id, data) {
			if (!Lyx.isUndefined(data)) {
				data = {
					[id]: data
				}
			}
			Lyx.each(data, function (id, value) {
				Lyx.each(this.model, function (key) {
					this.pool[id][key] = value[key];
				}, this);
				delete this.requestBuffer[id];
			}, this);
		}
	});

	/**
	 * 判断一个数是否在限制范围内，否则返回边界
	 * @param {number} min 下界
	 * @param {number} max 上届
	 * @param {number} value 判定值
	 * @returns {number}
	 */
	base.scope = function (min, max, value) {
		return value < min ? min : value > max ? max : value;
	}

	/**
	 * 中英文混合长度计算
	 * @param {string} string 要计算的字符串
	 * @returns {number} 字符串长度
	 */
	base.strLen = function (str) {
		var regEl = /^[a-z0-9A-Z]+$/;	// 匹配字母和数字
		var length = 0;
		for (var i = 0, len = str.length; i < len; i++) {
			if (regEl.test(str[i]) || str[i].charCodeAt() <= 128) {
				length++;
			}
			else {
				length += 2;
			}
		}
		return length;
	}

	/**
	 * 中英文混合字符串切割
	 * @param {string} string 字符串
	 * @param {number} length 要截取的长度
	 * @returns {string} 截取到的字符串
	 */
	base.cutString = function (str, length) {
		var temp = "";
		for (var i = 0, len = str.length; i < len; i++) {
			temp += str[i];
			if (base.strLen(temp) >= length * 2) {
				break;
			}
		}
		if (base.strLen(temp) < base.strLen(string)) {
			temp += "...";
		}
		return temp;
	}

	/**
	 * 格式化时间戳
	 * @param {Date} date 时间戳
	 * @param {string} fmt 格式
	 * @returns {string} 格式化后的字符串
	 */
	base.format = function (date, fmt) {
		fmt = fmt || "yyyy-MM-dd hh:mm:ss";
		var obj = {
			"M+": date.getMonth() + 1, //月份 
			"d+": date.getDate(), //日 
			"h+": date.getHours(), //小时 
			"m+": date.getMinutes(), //分 
			"s+": date.getSeconds(), //秒 
			"q+": Math.floor((date.getMonth() + 3) / 3), //季度 
			"S": date.getMilliseconds() //毫秒 
		};
		if (/(y+)/.test(fmt)) {
			fmt = fmt.replace(RegExp.$1, (date.getFullYear() + "").substr(4 - RegExp.$1.length));
		}
		Lyx.each(obj, function (key, value) {
			if (new RegExp("(" + key + ")").test(fmt)) {
				fmt = fmt.replace(RegExp.$1, (RegExp.$1.length == 1) ? (value) : (("00" + value).substr(("" + value).length)));
			}
		});
		return fmt;
	};

	/**
	 * 深拷贝一个对象
	 * @param {object} source 原对象
	 * @returns {object} 拷贝的对象
	 */
	base.copy = function (source) {
		var newObj = Lyx.isArrayLike(source) ? [] : {};
		var stack = [source];
		var obj;
		while (stack.length != 0) {
			obj = stack.pop();
			Lyx.each(obj, function (key, value) {
				if (Lyx.isBaseType(value)) {
					newObj[key] = value;
				}
				else {
					newObj[key] = Lyx.isArrayLike(value) ? [] : {}
					stack.push(value);
				}
			});
		}
		return newObj;
	}

	/**
	 * 重复执行一个函数
	 * @constructor
	 * @param {function} func 回调函数
	 * @param {number} [space = 0] 重复间隔
	 */
	base.interval = Lyx.createClass(function (p2t) {
		p2t.init = function (func, space) {
			/** 
			 * 要重复执行的函数
			 * @member {function}
			 */
			this.func = func;

			/**
			 * 重复间隔
			 * @member {number}
			 */
			this.space = space || 0;

			/**
			 * 执行次数
			 * @member {number}
			 */
			this.number = 0;

			/**
			 * 当前状态
			 * @member {boolean}
			 */
			this.status = false;

			/**
			 * setInterval获取到的id
			 * @member {number}
			 */
			this.id = null;


			this.$func = { chmod: "r" };
			this.$space = {
				set: function (value) {
					Lyx.log("space: " + value);
					this.start(value);
				}
			}
			this.start();
			Lyx.observe(this);
		}

		/**
		 * 重复执行的回调函数
		 * @memberof module:base.interval.prototype
		 */
		p2t.callback = function () {
			this.number++;
			try {
				this.func();
			}
			catch (error) {
				Lyx.log(error);
				this.stop();
			}
		}

		/**
		 * 停止重复执行回调函数
		 * @memberof module:base.interval.prototype
		 */
		p2t.stop = function () {
			clearInterval(this.id);
			this.id = null;
			this.status = false;
			if (Lyx.isFunction(this.onStop)) {
				this.onStop();
			}
			return this;
		}

		/**
		 * 开始重复执行回调函数
		 * @memberof module:base.interval.prototype
		 */
		p2t.start = function (space) {
			space = Lyx.isUndefined(space) ? this.space : space;
			if (this.status) {
				this.stop();
			}
			this.status = true;
			this.id = setInterval(this.callback.bind(this), space);
		}
	});

	/**
	 * 
	 * @param {function} callback 线程函数 
	 * @param {number} [space = 0] 等待间隔
	 */
	base.thread = function (callback, space) {
		return setTimeout(function () {
			callback();
		}, space || 0);
	}

	return base;
});